Bitset field


In [1]:
from konfoo import Index, Byteorder, Bitset, Bitset8, Bitset16, Bitset24, Bitset32, Bitset64

Item

Item type of the field class.


In [2]:
Bitset.item_type


Out[2]:
ItemClass.Bitset = 46

Checks if the field class is a bit field.


In [3]:
Bitset.is_bit()


Out[3]:
False

Checks if the field class is a boolean field.


In [4]:
Bitset.is_bool()


Out[4]:
False

Checks if the field class is a decimal number field.


In [5]:
Bitset.is_decimal()


Out[5]:
True

Checks if the field class is a floating point number field.


In [6]:
Bitset.is_float()


Out[6]:
False

Checks if the field class is a pointer field.


In [7]:
Bitset.is_pointer()


Out[7]:
False

Checks if the field class is a stream field.


In [8]:
Bitset.is_stream()


Out[8]:
False

Checks if the field class is a string field.


In [9]:
Bitset.is_string()


Out[9]:
False

Field


In [10]:
bitset = Bitset(bit_size=32, align_to=None, byte_order='auto')

In [11]:
bitset = Bitset(32)

Field view


In [12]:
bitset


Out[12]:
Bitset(index=Index(byte=0, bit=0, address=0, base_address=0, update=False), alignment=Alignment(byte_size=4, bit_offset=0), bit_size=32, value='0b00000000000000000000000000000000')

In [13]:
str(bitset)


Out[13]:
'Bitset32(Index(byte=0, bit=0, address=0, base_address=0, update=False), Alignment(byte_size=4, bit_offset=0), 32, 0b00000000000000000000000000000000)'

In [14]:
repr(bitset)


Out[14]:
"Bitset(index=Index(byte=0, bit=0, address=0, base_address=0, update=False), alignment=Alignment(byte_size=4, bit_offset=0), bit_size=32, value='0b00000000000000000000000000000000')"

Field name


In [15]:
bitset.name


Out[15]:
'Bitset32'

Field index


In [16]:
bitset.index


Out[16]:
Index(byte=0, bit=0, address=0, base_address=0, update=False)

Byte index of the field within the byte stream.


In [17]:
bitset.index.byte


Out[17]:
0

Bit offset relative to the byte index of the field within the byte stream.


In [18]:
bitset.index.bit


Out[18]:
0

Absolute address of the field within the data source.


In [19]:
bitset.index.address


Out[19]:
0

Base address of the byte stream within the data source.


In [20]:
bitset.index.base_address


Out[20]:
0

Indexes the field and returns the index after the field.


In [21]:
bitset.index_field(index=Index())


Out[21]:
Index(byte=4, bit=0, address=4, base_address=0, update=False)

Field alignment


In [22]:
bitset.alignment


Out[22]:
Alignment(byte_size=4, bit_offset=0)

Byte size of the field group which the field is aligned to.


In [23]:
bitset.alignment.byte_size


Out[23]:
4

Bit offset of the field within its aligned field group.


In [24]:
bitset.alignment.bit_offset


Out[24]:
0

Field size


In [25]:
bitset.bit_size


Out[25]:
32

Field byte order


In [26]:
bitset.byte_order


Out[26]:
Byteorder.auto = 'auto'

In [27]:
bitset.byte_order.value


Out[27]:
'auto'

In [28]:
bitset.byte_order.name


Out[28]:
'auto'

In [29]:
bitset.byte_order = 'auto'

In [30]:
bitset.byte_order = Byteorder.auto

Field value

Checks if the decimal field is signed or unsigned.


In [31]:
bitset.signed


Out[31]:
False

Maximal decimal field value.


In [32]:
bitset.max()


Out[32]:
4294967295

Minimal decimal field value.


In [33]:
bitset.min()


Out[33]:
0

Returns the bitset field value as a binary string prefixed with 0b.


In [34]:
bitset.value


Out[34]:
'0b00000000000000000000000000000000'

Returns the decimal field value aligned to its field group as a number of bytes.


In [35]:
bytes(bitset)


Out[35]:
b'\x00\x00\x00\x00'

In [36]:
bytes(bitset).hex()


Out[36]:
'00000000'

Returns the decimal field value as an integer number.


In [37]:
int(bitset)


Out[37]:
0

Returns the decimal field value as an floating point number.


In [38]:
float(bitset)


Out[38]:
0.0

Returns the decimal field value as a lowercase hexadecimal string prefixed with 0x.


In [39]:
hex(bitset)


Out[39]:
'0x0'

Returns the decimal field value as a binary string prefixed with 0b.


In [40]:
bin(bitset)


Out[40]:
'0b0'

Returns the decimal field value as an octal string prefixed with 0o.


In [41]:
oct(bitset)


Out[41]:
'0o0'

Returns the decimal field value as a boolean value.


In [42]:
bool(bitset)


Out[42]:
False

Returns the decimal field value as a signed integer number.


In [43]:
bitset.as_signed()


Out[43]:
0

Returns the decimal field value as an unsigned integer number.


In [44]:
bitset.as_unsigned()


Out[44]:
0

Field metadata

Returns the meatadata of the field as an ordered dictionary.


In [45]:
bitset.describe()


Out[45]:
OrderedDict([('address', 0),
             ('alignment', [4, 0]),
             ('class', 'Bitset32'),
             ('index', [0, 0]),
             ('max', 4294967295),
             ('min', 0),
             ('name', 'Bitset32'),
             ('order', 'auto'),
             ('signed', False),
             ('size', 32),
             ('type', 'Field'),
             ('value', '0b00000000000000000000000000000000')])

Deserialize


In [46]:
bitset.deserialize(bytes.fromhex('01000000'), byte_order='little')


Out[46]:
Index(byte=4, bit=0, address=4, base_address=0, update=False)

In [47]:
bitset.value


Out[47]:
'0b00000000000000000000000000000001'

In [48]:
bytes(bitset)


Out[48]:
b'\x01\x00\x00\x00'

In [49]:
bytes(bitset).hex()


Out[49]:
'01000000'

In [50]:
int(bitset)


Out[50]:
1

In [51]:
float(bitset)


Out[51]:
1.0

In [52]:
hex(bitset)


Out[52]:
'0x1'

In [53]:
bin(bitset)


Out[53]:
'0b1'

In [54]:
oct(bitset)


Out[54]:
'0o1'

In [55]:
bool(bitset)


Out[55]:
True

Serialize


In [56]:
buffer = bytearray()

In [57]:
bitset.value = 1

In [58]:
bitset.value = 1.0

In [59]:
bitset.value = 0x01

In [60]:
bitset.value = 0b1

In [61]:
bitset.value = 0o1

In [62]:
bitset.value = True

In [63]:
bitset.value = 0b1

In [64]:
bitset.serialize(buffer, byte_order='little')


Out[64]:
Index(byte=4, bit=0, address=4, base_address=0, update=False)

In [65]:
buffer.hex()


Out[65]:
'01000000'

In [66]:
bytes(bitset).hex()


Out[66]:
'01000000'

In [ ]: